home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / table.h < prev    next >
C/C++ Source or Header  |  1999-05-14  |  12KB  |  433 lines

  1. // $Id: table.h,v 1.3 1999/01/25 20:00:32 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #ifndef table_INCLUDED
  11. #define table_INCLUDED
  12.  
  13. #include "config.h"
  14. #include "symbol.h"
  15.  
  16. class VariableShadowSymbol
  17. public:
  18.     VariableSymbol *variable_symbol;
  19.  
  20.     VariableShadowSymbol(VariableSymbol *variable_symbol_) : variable_symbol(variable_symbol_),
  21.                                                              conflict(NULL)
  22.     {}
  23.  
  24.     ~VariableShadowSymbol()
  25.     {
  26.         delete conflict;
  27.     }
  28.  
  29.     VariableSymbol *Conflict(int i) { return (*conflict)[i]; }
  30.  
  31.     inline int NumConflicts()
  32.     {
  33.         return (conflict ? conflict -> Length() : 0);
  34.     }
  35.     inline void AddConflict(VariableSymbol *conflict_symbol)
  36.     {
  37.         if ((variable_symbol != conflict_symbol) && (! Find(conflict_symbol)))
  38.             conflict -> Next() = conflict_symbol;
  39.         return;
  40.     }
  41.     inline void CompressSpace()
  42.     {
  43.         if (conflict)
  44.             (void) conflict -> Array();
  45.     }
  46.  
  47. private:
  48.     friend class ExpandedFieldTable;
  49.     VariableShadowSymbol *next;
  50.  
  51.     ConvertibleArray<VariableSymbol *> *conflict;
  52.  
  53.     bool Find(VariableSymbol *conflict_symbol)
  54.     {
  55.         if (! conflict)
  56.             conflict = new ConvertibleArray<VariableSymbol *>(4);
  57.         for (int k = 0; k < conflict -> Length(); k++)
  58.             if ((*conflict)[k] == conflict_symbol)
  59.                 return true;
  60.         return false;
  61.     }    
  62. };
  63.  
  64.  
  65. class MethodShadowSymbol
  66. public:
  67.     MethodSymbol *method_symbol;
  68.     MethodShadowSymbol *next_method;
  69.  
  70.     MethodShadowSymbol(MethodSymbol *method_symbol_) : method_symbol(method_symbol_),
  71.                                                        conflict(NULL)
  72.     {}
  73.  
  74.     ~MethodShadowSymbol()
  75.     {
  76.         delete conflict;
  77.     }
  78.  
  79.     MethodSymbol *Conflict(const int i) { return (*conflict)[i]; }
  80.  
  81.     inline int NumConflicts()
  82.     {
  83.         return (conflict ? conflict -> Length() : 0);
  84.     }
  85.     inline void AddConflict(MethodSymbol *conflict_symbol)
  86.     {
  87.         if ((method_symbol != conflict_symbol) && (! Find(conflict_symbol)))
  88.             conflict -> Next() = conflict_symbol;
  89.         return;
  90.     }    
  91.     inline void RemoveConflicts()
  92.     {
  93.         delete conflict;
  94.         conflict = NULL;
  95.     }    
  96.  
  97.     inline void CompressSpace()
  98.     {
  99.         if (conflict)
  100.             (void) conflict -> Array();
  101.     }
  102.  
  103. private:
  104.     friend class ExpandedMethodTable;
  105.     MethodShadowSymbol *next;
  106.  
  107.     ConvertibleArray<MethodSymbol *> *conflict;
  108.  
  109.     bool Find(MethodSymbol *conflict_symbol)
  110.     {
  111.         if (! conflict)
  112.             conflict = new ConvertibleArray<MethodSymbol *>(4);
  113.         for (int k = 0; k < conflict -> Length(); k++)
  114.             if ((*conflict)[k] == conflict_symbol)
  115.                 return true;
  116.         return false;
  117.     }    
  118. };
  119.  
  120.  
  121. class TypeShadowSymbol
  122. public:
  123.     TypeSymbol *type_symbol;
  124.  
  125.     TypeShadowSymbol(TypeSymbol *type_symbol_) : type_symbol(type_symbol_),
  126.                                                  conflict(NULL)
  127.     {}
  128.  
  129.     ~TypeShadowSymbol()
  130.     {
  131.         delete conflict;
  132.     }
  133.  
  134.     TypeSymbol *Conflict(int i) { return (*conflict)[i]; }
  135.  
  136.     inline int NumConflicts()
  137.     {
  138.         return (conflict ? conflict -> Length() : 0);
  139.     }
  140.  
  141.     inline void AddConflict(TypeSymbol *conflict_symbol)
  142.     {
  143.         if ((type_symbol != conflict_symbol) && (! Find(conflict_symbol)))
  144.             conflict -> Next() = conflict_symbol;
  145.         return;
  146.     }
  147.  
  148.     inline void CompressSpace()
  149.     {
  150.         if (conflict)
  151.             (void) conflict -> Array();
  152.     }
  153.  
  154. private:
  155.     friend class ExpandedTypeTable;
  156.     TypeShadowSymbol *next;
  157.  
  158.     ConvertibleArray<TypeSymbol *> *conflict;
  159.  
  160.     bool Find(TypeSymbol *conflict_symbol)
  161.     {
  162.         if (! conflict)
  163.             conflict = new ConvertibleArray<TypeSymbol *>(4);
  164.         for (int k = 0; k < conflict -> Length(); k++)
  165.             if ((*conflict)[k] == conflict_symbol)
  166.                 return true;
  167.         return false;
  168.     }    
  169. };
  170.  
  171.  
  172. class ExpandedTypeTable
  173. {
  174. public:
  175.     enum
  176.     {
  177.         DEFAULT_HASH_SIZE = 251,
  178.         MAX_HASH_SIZE = 509
  179.     };
  180.  
  181.     ConvertibleArray<TypeShadowSymbol *> symbol_pool;
  182.  
  183.     inline void CompressSpace()
  184.     {
  185.         hash_size = symbol_pool.Length();
  186.         hash_size = (hash_size <= 0 ? 1 : (hash_size > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size));
  187.         delete [] base;
  188.         base = (TypeShadowSymbol **) memset(new TypeShadowSymbol *[hash_size], 0, hash_size * sizeof(TypeShadowSymbol *));
  189.  
  190.         TypeShadowSymbol **array = symbol_pool.Array();
  191.         for (int i = 0; i < symbol_pool.Length(); i++)
  192.         {
  193.             array[i] -> CompressSpace();
  194.  
  195.             int k = array[i] -> type_symbol -> name_symbol -> index % hash_size;
  196.             array[i] -> next = base[k];
  197.             base[k] = array[i];
  198.         }
  199.     }
  200.  
  201.     ExpandedTypeTable(int hash_size_ = DEFAULT_HASH_SIZE) : symbol_pool(10, 4)
  202.     {
  203.         hash_size = (hash_size_ <= 0 ? 1 : (hash_size_ > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size_));
  204.         base = (TypeShadowSymbol **) memset(new TypeShadowSymbol *[hash_size], 0, hash_size * sizeof(TypeShadowSymbol *));
  205.     }
  206.  
  207.     ~ExpandedTypeTable()
  208.     {
  209.         for (int k = 0; k < symbol_pool.Length(); k++)
  210.             delete symbol_pool[k];
  211.         delete [] base;
  212.     }
  213.  
  214.     inline void InsertTypeShadowSymbol(TypeSymbol *type_symbol)
  215.     {
  216.         int i = type_symbol -> name_symbol -> index % hash_size;
  217.         TypeShadowSymbol *p = new TypeShadowSymbol(type_symbol);
  218.         p -> next = base[i];
  219.         base[i] = p;
  220.         symbol_pool.Next() = p;
  221.         
  222.         return;
  223.     }
  224.  
  225.     inline TypeShadowSymbol *FindTypeShadowSymbol(NameSymbol *name_symbol)
  226.     {
  227.         TypeShadowSymbol *p;
  228.         for (p = base[name_symbol -> index % hash_size]; p; p = p -> next)
  229.              if (p -> type_symbol -> name_symbol == name_symbol)
  230.                  break;
  231.         return p;
  232.     }
  233.  
  234. private:
  235.     TypeShadowSymbol **base;
  236.     int hash_size;
  237. };
  238.  
  239. class ExpandedFieldTable
  240. {
  241. public:
  242.     enum
  243.     {
  244.         DEFAULT_HASH_SIZE = 251,
  245.         MAX_HASH_SIZE = 509
  246.     };
  247.  
  248.     ConvertibleArray<VariableShadowSymbol *> symbol_pool;
  249.  
  250.     inline void CompressSpace()
  251.     {
  252.         hash_size = symbol_pool.Length();
  253.         hash_size = (hash_size <= 0 ? 1 : (hash_size > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size));
  254.         delete [] base;
  255.         base = (VariableShadowSymbol **) memset(new VariableShadowSymbol *[hash_size], 0, hash_size * sizeof(VariableShadowSymbol *));
  256.  
  257.         VariableShadowSymbol **array = symbol_pool.Array();
  258.         for (int i = 0; i < symbol_pool.Length(); i++)
  259.         {
  260.             array[i] -> CompressSpace();
  261.  
  262.             int k = array[i] -> variable_symbol -> name_symbol -> index % hash_size;
  263.             array[i] -> next = base[k];
  264.             base[k] = array[i];
  265.         }
  266.     }
  267.  
  268.     ExpandedFieldTable(int hash_size_ = DEFAULT_HASH_SIZE) : symbol_pool(10, 4)
  269.     {
  270.         hash_size = (hash_size_ <= 0 ? 1 : (hash_size_ > MAX_HASH_SIZE ? MAX_HASH_SIZE : hash_size_));
  271.         base = (VariableShadowSymbol **) memset(new VariableShadowSymbol *[hash_size], 0, hash_size * sizeof(VariableShadowSymbol *));
  272.     }
  273.     ~ExpandedFieldTable()
  274.     {
  275.         for (int i = 0; i < symbol_pool.Length(); i++)
  276.             delete symbol_pool[i];
  277.         delete [] base;
  278.     }
  279.  
  280.     inline void InsertVariableShadowSymbol(VariableSymbol *variable_symbol)
  281.     {
  282.         int i = variable_symbol -> name_symbol -> index % hash_size;
  283.         VariableShadowSymbol *p = new VariableShadowSymbol(variable_symbol);
  284.         p -> next = base[i];
  285.         base[i] = p;
  286.         symbol_pool.Next() = p;
  287.  
  288.         return;
  289.     }
  290.  
  291.     inline VariableShadowSymbol *FindVariableShadowSymbol(NameSymbol *name_symbol)
  292.     {
  293.         VariableShadowSymbol *p;
  294.         for (p = base[name_symbol -> index % hash_size]; p; p = p -> next)
  295.             if (p -> variable_symbol -> name_symbol == name_sy